/**
 * Software License, Version 1.0
 *
 * Copyright 2003 The Trustees of Indiana University.  All rights reserved.
 *
 *
 *Redistribution and use in source and binary forms, with or without
 *modification, are permitted provided that the following conditions are met:
 *
 *1) All redistributions of source code must retain the above copyright notice,
 * the list of authors in the original source code, this list of conditions and
 * the disclaimer listed in this license;
 *2) All redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the disclaimer listed in this license in
 * the documentation and/or other materials provided with the distribution;
 *3) Any documentation included with all redistributions must include the
 * following acknowledgement:
 *
 *"This product includes software developed by the Community Grids Lab. For
 * further information contact the Community Grids Lab at
 * http://communitygrids.iu.edu/."
 *
 * Alternatively, this acknowledgement may appear in the software itself, and
 * wherever such third-party acknowledgments normally appear.
 *
 *4) The name Indiana University or Community Grids Lab or NaradaBrokering,
 * shall not be used to endorse or promote products derived from this software
 * without prior written permission from Indiana University.  For written
 * permission, please contact the Advanced Research and Technology Institute
 * ("ARTI") at 351 West 10th Street, Indianapolis, Indiana 46202.
 *5) Products derived from this software may not be called NaradaBrokering,
 * nor may Indiana University or Community Grids Lab or NaradaBrokering appear
 * in their name, without prior written permission of ARTI.
 *
 *
 * Indiana University provides no reassurances that the source code provided
 * does not infringe the patent or any other intellectual property rights of
 * any other entity.  Indiana University disclaims any liability to any
 * recipient for claims brought by any other entity based on infringement of
 * intellectual property rights or otherwise.
 *
 *LICENSEE UNDERSTANDS THAT SOFTWARE IS PROVIDED "AS IS" FOR WHICH NO
 *WARRANTIES AS TO CAPABILITIES OR ACCURACY ARE MADE. INDIANA UNIVERSITY GIVES
 *NO WARRANTIES AND MAKES NO REPRESENTATION THAT SOFTWARE IS FREE OF
 *INFRINGEMENT OF THIRD PARTY PATENT, COPYRIGHT, OR OTHER PROPRIETARY RIGHTS.
 *INDIANA UNIVERSITY MAKES NO WARRANTIES THAT SOFTWARE IS FREE FROM "BUGS",
 *"VIRUSES", "TROJAN HORSES", "TRAP DOORS", "WORMS", OR OTHER HARMFUL CODE.
 *LICENSEE ASSUMES THE ENTIRE RISK AS TO THE PERFORMANCE OF SOFTWARE AND/OR
 *ASSOCIATED MATERIALS, AND TO THE PERFORMANCE AND VALIDITY OF INFORMATION
 *GENERATED USING SOFTWARE.
 */

package cgl.narada.service.storage.db;

import java.io.File;
import java.util.Properties;

import cgl.narada.gui.admin.reliable.UserConfigure;
import cgl.narada.service.ServiceException;
import cgl.narada.util.ConfigurationParamsReader;
/**
 * <p>Title: DatabaseFactory</p>
 * <p>Description: Creates a static instance of DataAccessObject to
 * do task on database</p>
 * @author Beytullah Yildiz
 * @version 1.0
 */

public class DatabaseFactory {
  private String DEFAULT_PROP_FILE = "../config/ServiceConfiguration.txt";
  private static Properties properties = null;
  private static Properties serviceDefaults;
  private static DataAccessObject dao;
  private String moduleName = "DatabaseFactory: ";

  public DatabaseFactory() {

  }
  /**
   * composes connection information variable
   * @param param array of parameters
   */
  public String getConnnectionInfo(String[] param) {
    String connectionInfo = null;
    if (param[3] == "") {
      connectionInfo = param[1] + "://" + param[2] + "/" + param[4];
    }
    else {
      connectionInfo = param[1] + "://" + param[2] + ":" + param[3] + "/" +
          param[4];
    }
    return connectionInfo;
  }
  /**
   * creates new instance of DataAccessObject by getting username and
   * password from UserConfigure file
   */
  public void createDAO() {

    try {
      String[] connectParam = new String[5];
      loadProperties(connectParam);
      String connectInfo = getConnnectionInfo(connectParam);

      String username = UserConfigure.getDbUserID();
      String userpass = UserConfigure.getDbUserPassword();

      createDAO(connectParam[0], connectInfo, username, userpass);

    }
    catch (Exception ex) {
      ex.printStackTrace();
    }

  }
  /**
   * creates new instance of DataAccessObject
   * @param driver database driver
   * @param conInfo connection information for database
   * @param uname database username
   * @param password database user password
   * @throws ServiceException
   */
  public void createDAO(String driver, String conInfo, String uname,
                        String password) throws ServiceException {

    dao = new DataAccessObject();
    dao.setDriver(driver);
    dao.setConnnectionInfo(conInfo);
    dao.setUserParameters(uname, password);
    dao.initilizeConnection();
  }
  /**
   * @return DataAccessObject if it is null it creates new one and sets
   * it to the static variable of this object
   * @throws ServiceException
   */
  public DataAccessObject getDAO() throws ServiceException {
    if (dao == null) {
      createDAO();
    }

    return dao;
  }
  /**
   * @return Properties for a given file
   * @throws Exception
   */
  public Properties getProperties() throws Exception {
    if (serviceDefaults == null) {
      initializeServiceDefaults();
    }
    String fileLocation = UserConfigure.getDbConfFile();
    File file = new File(fileLocation);
    Properties serviceProperties;

    if (!file.exists()) {
      System.out.println(moduleName + "Specified file does not exist" +
			 " Will revert to service defaults!");
      serviceProperties = new Properties(serviceDefaults);
      System.out.println(serviceProperties);
      return serviceProperties;
    }

    ConfigurationParamsReader configReader =
      new ConfigurationParamsReader(fileLocation);
    serviceProperties = configReader.getProperties(serviceDefaults);

    return serviceProperties;

    /*if (fileName.equals("")|| fileName == null) {
       fileName = DEFAULT_PROP_FILE;
       }
       if (properties != null) {
       return properties;
       }

       Properties p = null;

       File file = new File(fileName);
       if (file.exists()) {
       p = new Properties();
       p.load(new FileInputStream(file));
       }

       properties = p;
       return p;*/
  }


  private void initializeServiceDefaults() {
    serviceDefaults = new Properties();
    serviceDefaults.setProperty("StorageType", "db");

    serviceDefaults.setProperty("Database_JDBC_Driver",
				"org.gjt.mm.mysql.Driver");
    serviceDefaults.setProperty("Database_ConnectionProvider",
				"jdbc:mysql");
    serviceDefaults.setProperty("Database_ConnectionHost",
				"localhost");
    serviceDefaults.setProperty("Database_ConnectionDatabase",
				"NbPersistence");
    serviceDefaults.setProperty("FileStorage_BaseDirectory",
				"C:/NBStorage/filebased/persistent");
  }

  /**
   * loads parameters to connect database
   * @param connectParameters parameter rewired for connection
   * @throws Exception
   */
  public void loadProperties(String[] connectParameters) throws Exception {

    Properties properties = getProperties();

    connectParameters[0] = properties.getProperty("Database_JDBC_Driver").
        trim();
    connectParameters[1] = properties.getProperty(
        "Database_ConnectionProvider", "").trim();
    connectParameters[2] = properties.getProperty("Database_ConnectionHost", "").
        trim();
    connectParameters[3] = properties.getProperty("Database_ConnectionPor", "").
        trim();
    connectParameters[4] = properties.getProperty(
        "Database_ConnectionDatabase", "").trim();

  }

  public static void main(String[] args) {
    DatabaseFactory df = new DatabaseFactory();
    try {
      df.getDAO();
    }
    catch (Exception ex) {
      System.out.println("exception");
    }

  }

}
